// background.js - Chrome 扩展的后台服务工作者

// 保存拦截的请求数据
let capturedRequests = [];

// 保存同步失败的数据
let failedSyncData = [];

console.log('🚀 Background Service Worker 已启动');

// 添加一个明确的启动函数
function initializeBackgroundScript() {
  console.log('🔧 初始化 Background Script');
  
  // 初始化时加载已保存的数据
  chrome.storage.local.get(['capturedRequests', 'failedSyncData'], (result) => {
    if (result.capturedRequests) {
      capturedRequests = result.capturedRequests;
      console.log('📚 已加载历史记录:', capturedRequests.length, '条');
    }
    
    if (result.failedSyncData) {
      failedSyncData = result.failedSyncData;
      console.log('📚 已加载失败同步数据:', failedSyncData.length, '条');
    }
  });
  
  // 保持 service worker 活跃（可选）
  keepAlive();
  
  // 确保监听器已注册
  registerListeners();
}

// 注册所有监听器
function registerListeners() {
  console.log('🔌 注册监听器');
  
  // 检查 tabs 监听器是否已注册
  try {
    chrome.tabs.onUpdated.hasListener(handleTabUpdate) || chrome.tabs.onUpdated.addListener(handleTabUpdate);
    console.log('✅ Tabs 更新监听器已注册');
  } catch (error) {
    console.error('❌ Tabs 更新监听器注册失败:', error);
  }
}

// 处理标签页更新的函数
function handleTabUpdate(tabId, changeInfo, tab) {
  console.log('监听页面页签更新事件:', tabId, changeInfo, tab?.url);
  
  if (changeInfo.status === 'complete' && tab?.url) {
    console.log('监听页面加载完成:', tab.url);
    
    // 获取拦截规则
    chrome.storage.local.get(['interceptionRules'], (result) => {
      console.log('从存储中获取拦截规则:', result);
      
      if (result && result.interceptionRules) {
        let interceptionRules = [];
        // 检查是否为数组格式
        if (Array.isArray(result.interceptionRules)) {
          interceptionRules = result.interceptionRules;
        } else if (typeof result.interceptionRules === 'object') {
          // 如果是对象格式，转换为数组
          interceptionRules = Object.values(result.interceptionRules);
        }
        
        console.log('当前拦截规则:', interceptionRules);
        
        // 检查是否有匹配的页面HTML捕获规则
        let matchedRule = null;
        for (const rule of interceptionRules) {
          console.log('检查规则:', rule.name, rule.dataType, rule.urlPattern, rule.enabled);
          
          if (rule.enabled !== false && 
              rule.dataType === 'page_html' &&
              isUrlMatch(tab.url, rule.urlPattern, rule.matchType)) {
            matchedRule = rule;
            console.log('✅ 匹配到页面HTML捕获规则:', rule.name);
            break;
          }
        }
        
        // 如果匹配到页面HTML捕获规则，则发送页面HTML到API
        if (matchedRule) {
          console.log('准备获取页面HTML内容');
          
          // 获取页面HTML内容 - 使用 Manifest V3 的 API
          chrome.scripting.executeScript({
            target: { tabId: tabId },
            func: () => document.documentElement.outerHTML
          }, (results) => {
            if (chrome.runtime.lastError) {
              console.error('❌ 获取页面HTML失败:', chrome.runtime.lastError);
            } else if (results && results[0]) {
              const pageHtml = results[0].result;
              console.log('✅ 成功获取页面HTML，长度:', pageHtml.length);
              
              // 构造数据并发送到API
              const requestData = {
                url: tab.url,
                method: 'GET',
                timestamp: new Date().toISOString(),
                response: { html: pageHtml.substring(0, 1000) + '...' }, // 只发送前1000字符作为示例
                status: 200,
                pageHtml: pageHtml // 完整的页面HTML
              };
              
              console.log('🚀 发送页面HTML到API端点:', matchedRule.apiEndpoint);
              sendToApi(matchedRule.apiEndpoint, requestData, matchedRule.dataType);
            } else {
              console.log('❌ 未获取到页面HTML内容');
            }
          });
        } else {
          console.log('未匹配到页面HTML捕获规则');
        }
      } else {
        console.log('未找到拦截规则');
      }
    });
  }
}

// 保持 service worker 活跃（可选）
let keepAliveInterval;
function keepAlive() {
  if (keepAliveInterval) clearInterval(keepAliveInterval);
  keepAliveInterval = setInterval(() => {
    chrome.storage.local.get('keepAlive', () => {
      // 只是为了保持连接
    });
  }, 20000); // 每20秒ping一次
}

// 监听来自 content script 的消息
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  console.log('📨 收到消息:', request.action);
  
  if (request.action === 'saveResponse') {
    console.log('💾 开始保存响应数据...');
    console.log('请求URL:', request.url);
    console.log('响应数据:', request.response);
    console.log('数据类型:', request.dataType);
    
    // 保存响应数据（使用与popup和options页面兼容的格式）
    const requestData = {
      id: 'req_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9),
      url: request.url,
      method: request.method,
      timestamp: request.timestamp,
      response: request.response,
      status: request.status,
      // 添加dataType字段，优先使用content script发送的dataType，如果没有则使用自己的判断
      dataType: request.dataType || determineDataType(request.url),
      // 添加pageHtml字段（如果存在）
      pageHtml: request.pageHtml,
      // 添加shopIds字段（如果存在）
      shopIds: request.shopIds
    };
    
    capturedRequests.push(requestData);
    console.log('📊 当前已拦截请求数:', capturedRequests.length);
    console.log('📊 保存的数据:', requestData);
    
    // 保存到本地存储
    chrome.storage.local.set({
      capturedRequests: capturedRequests
    }, () => {
      console.log('✅ 已保存到storage');
      // 验证数据是否正确保存
      chrome.storage.local.get(['capturedRequests'], (result) => {
        console.log('验证保存的数据:', result.capturedRequests?.length || 0, '条');
      });
    });
    
    // 下载JSON文件
    downloadAsJson(requestData);
    
    sendResponse({ success: true });
  } else if (request.action === 'getRequests') {
    console.log('📋 请求获取历史记录, 当前数量:', capturedRequests.length);
    sendResponse({ requests: capturedRequests });
  } else if (request.action === 'downloadData') {
    // 下载数据为 JSON 文件
    downloadAsJson(request.data, request.filename);
    sendResponse({ success: true });
  } else if (request.action === 'syncData') {
    // 处理数据同步请求
    syncAllData();
    sendResponse({ success: true });
  } else if (request.action === 'retryFailedSync') {
    // 重新同步失败的数据
    retryFailedSync(request.dataItem);
    sendResponse({ success: true });
  } else if (request.action === 'getFailedSyncData') {
    // 获取失败同步数据
    sendResponse({ failedSyncData: failedSyncData });
  }
  
  // 保持消息通道开放以支持异步响应
  return true;
});

// 监听service worker的生命周期
self.addEventListener('activate', (event) => {
  console.log('🔄 Service Worker 已激活');
  initializeBackgroundScript();
});

// 监听扩展安装事件
chrome.runtime.onInstalled.addListener((details) => {
  console.log('Extension installed or updated:', details);
  
  if (details.reason === 'install') {
    // 首次安装时的初始化操作
    console.log('Extension installed for the first time');
  } else if (details.reason === 'update') {
    // 更新时的操作
    console.log('Extension updated from version', details.previousVersion);
  }
  
  // 初始化background script
  initializeBackgroundScript();
});

// 监听扩展启动事件
chrome.runtime.onStartup.addListener(() => {
  console.log('🚀 Extension startup');
  initializeBackgroundScript();
});

// 保存数据到本地存储（保持与原始版本一致的格式）
function saveToLocalStorage(data) {
  try {
    const key = `hzbank_${new Date().getTime()}`;
    const allData = JSON.parse(localStorage.getItem('hzbank_requests') || '[]');
    allData.push({
      key: key,
      timestamp: data.timestamp,
      url: data.url,
      data: data
    });
    
    // 只保留最近100条记录
    if (allData.length > 100) {
      allData.shift();
    }
    
    localStorage.setItem('hzbank_requests', JSON.stringify(allData));
    console.log('💾 已保存到本地存储，共', allData.length, '条记录');
  } catch (e) {
    console.error('保存到本地存储失败:', e);
  }
}

// 根据URL确定数据类型（大小写不敏感）
function determineDataType(url) {
  // 移除查询参数，只检查路径部分，并转换为小写进行比较
  const path = url.split('?')[0].toLowerCase();
  
  if (path.includes('bank') || path.includes('transaction') || path.includes('hzdealreport')) {
    return 'bank';
  } else if (path.includes('purchase') && path.includes('order')) {
    return 'purchase_order';
  } else if (path.includes('order') || path.includes('mall')) {
    return 'sales_order';
  } else if (path.includes('qlfpcx')) {
    // 进项发票查询接口
    return 'incoming_invoice';
  } else if (path.includes('fpxxcx')) {
    // 销项发票查询接口
    return 'outgoing_invoice';
  } else if (path.includes('invoice') || path.includes('fpjcxx')) {
    // 其他发票相关接口
    return 'invoice';
  } else if (path.includes('announcement') || path.includes('querypage')) {
    return 'announcement';
  } else if (path.includes('search') && path.includes('front')) {
    // 商品搜索接口
    return 'product_search';
  }
  return 'unknown';
}

// 下载数据为 JSON 文件
function downloadAsJson(data) {
  console.log('📥 准备下载JSON文件...');
  const jsonStr = JSON.stringify(data, null, 2);
  const blob = new Blob([jsonStr], { type: 'application/json' });
  const url = URL.createObjectURL(blob);
  
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
  const filename = `request_${timestamp}.json`;
  
  chrome.downloads.download({
    url: url,
    filename: filename,
    saveAs: false
  }, (downloadId) => {
    if (chrome.runtime.lastError) {
      console.error('❌ 下载失败:', chrome.runtime.lastError);
    } else {
      console.log('✅ 文件已下载:', filename, '下载ID:', downloadId);
    }
    URL.revokeObjectURL(url);
  });
}

// 同步所有数据
function syncAllData() {
  console.log('开始同步所有数据');
  // 这里可以添加实际的数据同步逻辑
  // 例如发送数据到服务器等
  
  // 模拟同步过程
  capturedRequests.forEach((item, index) => {
    // 模拟同步失败的情况（10%的概率）
    if (Math.random() < 0.1) {
      const failedItem = {
        ...item,
        id: 'failed_' + Date.now() + '_' + index,
        errorMessage: '网络连接超时',
        retryCount: 0
      };
      
      failedSyncData.push(failedItem);
      console.log('❌ 同步失败:', item.url);
    }
  });
  
  // 保存失败数据到存储
  chrome.storage.local.set({
    failedSyncData: failedSyncData
  }, () => {
    console.log('✅ 失败同步数据已保存到storage');
  });
  
  console.log('✅ 数据同步完成');
}

// 重新同步失败的数据
function retryFailedSync(dataItem = null) {
  if (dataItem) {
    // 重新同步单个失败的数据
    console.log('🔄 重新同步单个失败数据:', dataItem.url);
    
    // 模拟同步过程
    // 这里应该添加实际的同步逻辑
    setTimeout(() => {
      // 模拟同步成功
      console.log('✅ 重新同步成功:', dataItem.url);
      
      // 从失败列表中移除
      failedSyncData = failedSyncData.filter(item => item.id !== dataItem.id);
      
      // 更新存储
      chrome.storage.local.set({
        failedSyncData: failedSyncData
      }, () => {
        console.log('✅ 失败同步数据已更新到storage');
      });
    }, 1000);
  } else {
    // 重新同步所有失败的数据
    console.log('🔄 重新同步所有失败数据，共', failedSyncData.length, '条');
    
    if (failedSyncData.length === 0) {
      console.log('ℹ️ 没有失败的同步数据');
      return;
    }
    
    // 模拟同步过程
    // 这里应该添加实际的同步逻辑
    setTimeout(() => {
      // 模拟同步成功
      console.log('✅ 所有失败数据重新同步成功');
      
      // 清空失败列表
      failedSyncData = [];
      
      // 更新存储
      chrome.storage.local.set({
        failedSyncData: failedSyncData
      }, () => {
        console.log('✅ 失败同步数据已清空');
      });
    }, 2000);
  }
}

// 发送数据到 API
function sendToApi(apiUrl, data, ruleDataType) {
  console.log('🚀 发送数据到:', apiUrl);
  
  // 确定数据类型
  const dataType = ruleDataType || determineDataType(data.url);
  
  // 构造符合新API格式的数据
  const pluginData = {
    batchId: 'batch_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9),
    timestamp: new Date().toISOString(),
    dataType: dataType,  // 使用确定的数据类型
    data: [{
      ...data,
      currentPageUrl: data.url,  // 添加当前页面的完整URL
      ruleInfo: {
        dataType: dataType  // 添加规则信息中的数据类型
      }
    }]
  };
  
  // 如果有页面HTML内容，则添加到pluginData中
  if (data.pageHtml) {
    pluginData.pageHtml = data.pageHtml;
  }
  
  // 如果有shopIds，则添加到pluginData中
  if (data.shopIds && Array.isArray(data.shopIds)) {
    pluginData.shopIds = data.shopIds;
  }
  
  console.log('📤 准备发送的数据:', JSON.stringify(pluginData, null, 2));
  
  fetch(apiUrl, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(pluginData)
  })
  .then(response => {
    if (response.ok) {
      return response.json();
    } else {
      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
    }
  })
  .then(result => {
    console.log('✅ 发送成功:', apiUrl);
    console.log('📥 API响应:', result);
  })
  .catch(error => {
    console.error('❌ 发送失败:', apiUrl, error);
    console.log('💾 失败的数据已保存到localStorage，可稍后重试');
  });
}

// 注意：标签页更新事件监听器已在registerListeners函数中注册
// 请勿在此处重复注册，避免冲突

// URL匹配函数
function isUrlMatch(url, pattern, matchType) {
  console.log('URL匹配检查:', url, pattern, matchType);
  
  // 如果没有指定匹配类型，默认使用includes
  if (!matchType || matchType === 'includes') {
    const result = url.includes(pattern);
    console.log('Includes匹配结果:', result);
    return result;
  }
  
  // 精确匹配
  if (matchType === 'exact') {
    // 移除查询参数后进行精确匹配
    const urlWithoutQuery = url.split('?')[0];
    const result = urlWithoutQuery === pattern;
    console.log('精确匹配结果:', result);
    return result;
  }
  
  // 前缀匹配
  if (matchType === 'startsWith') {
    const result = url.startsWith(pattern);
    console.log('前缀匹配结果:', result);
    return result;
  }
  
  // 后缀匹配
  if (matchType === 'endsWith') {
    const result = url.endsWith(pattern);
    console.log('后缀匹配结果:', result);
    return result;
  }
  
  // 正则表达式匹配
  if (matchType === 'regex') {
    try {
      const regex = new RegExp(pattern);
      const result = regex.test(url);
      console.log('正则匹配结果:', result);
      return result;
    } catch (e) {
      console.error('❌ 正则表达式错误:', pattern, e);
      return false;
    }
  }
  
  // 默认使用includes
  const result = url.includes(pattern);
  console.log('默认匹配结果:', result);
  return result;
}

console.log('Background service worker loaded');